home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Mail / tnextmail / Source / msgtortf.c < prev    next >
C/C++ Source or Header  |  1992-08-05  |  3KB  |  147 lines
  1. /* $Id: msgtortf.c,v 1.2 91/05/25 15:08:20 cap Exp $
  2.  * Read an input stream, which was prepared by the user, and write out an
  3.  * RTF file that references any attachments.
  4.  */
  5.  
  6. #include <stdio.h>
  7. #include <ctype.h>
  8. #ifndef USG
  9. #include <sys/param.h>
  10. #endif
  11. #include "config.h"
  12.  
  13. extern char rtf_name[];
  14. extern int rtfpos;
  15. extern char fatalerrors;
  16.  
  17. /* 
  18.  * msgtortf - translate an ascii message to trivial RTF. Support the 
  19.  *            \attach command.
  20.  */
  21.  
  22. msgtortf(in, out)
  23.      FILE *in, *out;
  24. {
  25.     int c;
  26.  
  27.     while ((c = getc(in)) != EOF) {
  28.     switch (c) {
  29.       case '\\':
  30.         if (handlebslash(in, out) < 0)
  31.         return;        /* error occurred */
  32.         break;
  33.       case '{':
  34.       case '}':
  35.       case '\n':
  36.         putc('\\', out);
  37.       default:
  38.         putc(c, out); rtfpos++;
  39.     }
  40.     }
  41. }
  42.  
  43. /* 
  44.  * handlebslash - We have seen a backslash in the input. If the user 
  45.  *                is using the \attach command, we parse the command 
  46.  *                out of the input stream. Otherwise, we have to quote 
  47.  *                the backslash and continue normal processing.
  48.  */
  49.  
  50. int handlebslash(in, out)
  51.      FILE *in, *out;
  52. {
  53.     static char attach[] = "attach";
  54.     char *ap = attach;
  55.     char sourceword[MAXPATHLEN], *sp = sourceword;
  56.     int si;
  57.     /* indicators for sightings of braces */
  58.     char bracelevel = 0;
  59.     int c;
  60.  
  61.     while (*ap) {
  62.     *sp = getc(in);
  63.     if (*sp++ != *ap++)    /* no match */
  64.         goto nomatch;
  65.     }
  66.     /* we've matched "attach", but make sure we're at the end of a word */
  67.     *sp = getc(in);
  68.     if (*sp == '{')
  69.     bracelevel++;
  70.     else if (!isspace(*sp)) {
  71.     /* 
  72.      * user said something like \attachmumble, which we pass 
  73.      * through as plain text.
  74.      */
  75.       nomatch:
  76.     fprintf(out, "\\\\");
  77.     fwrite(sourceword, sp + 1 - sourceword, 1, out);
  78.     rtfpos += sp + 2 - sourceword;
  79.     return 0;
  80.     }
  81.     /* 
  82.      * At this point we're sure we have an attach command. It is now 
  83.      * an error to have anything but whitespace until we see an open 
  84.      * brace. We also are sure that we don't have to punt the command 
  85.      * parsing and output \attablah . . ., so we can use sourceword 
  86.      * for something else. We will use it for collecting the filename 
  87.      * of the attachment.
  88.      */
  89.     sp = sourceword;
  90.     while (!bracelevel) {
  91.     *sp = getc(in);
  92.     if (*sp == '{')
  93.         bracelevel++;
  94.     else if (!isspace(*sp)) {
  95.         fatalerrors++;
  96.         fprintf(stderr, "Malformed \\attach command\n");
  97.         return -1;
  98.     }
  99.     }
  100.     /* 
  101.      * Now we've reached the argument of the attach---the filename. We 
  102.      * copy filename information until bracelevel returns to zero.
  103.      */
  104.     for (si = 0; bracelevel; si++) {
  105.     int c;
  106.     
  107.     if (si == sizeof sourceword) {
  108.         fprintf(stderr, "Argument to \\attach too long\n");
  109.         fatalerrors++;
  110.         return -1;
  111.     }
  112.     c = getc(in);
  113.     if (c == '}') {
  114.         bracelevel--;
  115.         *sp = '\0'; /* terminate filename */
  116.     } else if (c == EOF) {
  117.         fatalerrors++;
  118.         fprintf(stderr, "Premature EOF in \\attach command\n");
  119.         return -1;
  120.     } else
  121.         *sp++ = c;
  122.     }
  123.     *sp = '\0';
  124.     /* 
  125.      * We now have the attach argument in sourceword. We send it to 
  126.      * the attach handler.
  127.      */
  128.     return rtfattach(out, sourceword);
  129. }
  130.  
  131. /* rtf_start - write the rtf header to the rtf file */
  132.  
  133. rtf_start(file)
  134.      FILE *file;
  135. {
  136.     fprintf(file, "{\\rtf0\\ansi{\\fonttbl\\f1\\fnil %s;}\\f1\\fs%d\n",
  137.         FONTNAME, FONTSIZE * 2);
  138. }
  139.  
  140. /* rtf_end - write trailing information to the rtf file */
  141.  
  142. rtf_end(file)
  143.      FILE *file;
  144. {
  145.     fprintf(file, "}\n");
  146. }
  147.